home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 April: Mac OS SDK / Dev.CD Apr 99 SDK1.toast / Development Kits / Mac OS USB DDK / Examples / MouseModule / HIDEmulation.c next >
Encoding:
C/C++ Source or Header  |  1999-02-10  |  6.0 KB  |  211 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        HIDEmulation.c
  3.  
  4.     Contains:    HID Emulation glue code between the ADB SHIM and the USB Mouse HID Module
  5.  
  6.     Version:    xxx put version here xxx
  7.  
  8.     Copyright:    © 1998 by Apple Computer, Inc., all rights reserved.
  9.  
  10. */
  11.  
  12. #include <Types.h>
  13. #include <Devices.h>
  14. #include <DriverServices.h>
  15. #include <CursorDevices.h>
  16. #include <USB.h>
  17.  
  18.  
  19. #include "MouseModule.h"
  20.  
  21. extern    usbMousePBStruct myMousePB;
  22.  
  23. void USBMouseIn(UInt32 refcon, void * theData)
  24. {
  25. #pragma unused (refcon)
  26.  
  27. USBHIDDataPtr    pMouseData;
  28. static UInt16     oldbuttons = 0;
  29. UInt16     changedbuttons = 0;
  30.  
  31. //    DebugStr("\pIn USBMouseIn");
  32.     pMouseData = (USBHIDDataPtr)theData;
  33.     
  34.     if (myMousePB.pCursorDeviceInfo)        // don't call cursor device manager functions without a good cursor device
  35.     {
  36.         // Tell the Cursor Device Manager that we moved
  37.         if ((pMouseData->mouse.XDelta != 0) || (pMouseData->mouse.YDelta !=0))
  38.         {
  39.             CursorDeviceMove(myMousePB.pCursorDeviceInfo, pMouseData->mouse.XDelta, pMouseData->mouse.YDelta);
  40.         }
  41.         
  42.         // Update with the state of the buttons.
  43.         pMouseData->mouse.buttons &= 0x07;
  44.         changedbuttons = oldbuttons ^ pMouseData->mouse.buttons;
  45.         if (changedbuttons)
  46.         {
  47.             CursorDeviceButtons(myMousePB.pCursorDeviceInfo, (short)pMouseData->mouse.buttons);
  48.         }
  49.         oldbuttons = pMouseData->mouse.buttons;
  50.     }
  51. }
  52.  
  53. OSStatus USBHIDInstallInterrupt(HIDInterruptProcPtr HIDInterruptFunction, UInt32 refcon)
  54. {
  55.     USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Set interrupt pointer", (UInt32)HIDInterruptFunction);
  56.     myMousePB.interruptRefcon = refcon;            
  57.     
  58.     if (HIDInterruptFunction == USBMouseIn)                // if someone is installing the USBMouseIn routine then this is
  59.     {                                                    // an indication that someone earlier requested the interrupt
  60.         myMousePB.pSHIMInterruptRoutine = nil;            // pointer, saved it, and restored it.  When the USBMouseIn
  61.         USBHIDControlDevice(kHIDEnableDemoMode, 0);        // routine is to be used, we've got to re-enable demo mode,
  62.                                                         // otherwise there won't be a cursor device manager entry for us...
  63.     }
  64.     else
  65.     {
  66.         USBHIDControlDevice(kHIDDisableDemoMode, 0);    // disable demo mode
  67.         myMousePB.pSHIMInterruptRoutine = HIDInterruptFunction;
  68.     }
  69.     return noErr;
  70. }
  71.  
  72. OSStatus USBHIDPollDevice(void)
  73. {
  74.     return kUSBInternalErr;
  75. }
  76.  
  77. OSStatus USBHIDControlDevice(UInt32 theControlSelector, void * theControlData)
  78. {
  79. #pragma unused (theControlData)
  80.  
  81.     switch (theControlSelector)
  82.     {
  83.         case kHIDRemoveInterruptHandler:
  84.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Removing interrupt handler!!!", myMousePB.interfaceRef);
  85.             myMousePB.interruptRefcon = nil;
  86.             myMousePB.pSavedInterruptRoutine = nil;
  87.             myMousePB.pSHIMInterruptRoutine = nil;
  88.             if (myMousePB.pCursorDeviceInfo != 0)
  89.             {
  90.                 CursorDeviceDisposeDevice(myMousePB.pCursorDeviceInfo);
  91.                 myMousePB.pCursorDeviceInfo = 0;
  92.             }
  93.             break;
  94.             
  95.         case kHIDEnableDemoMode:
  96.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Demo Mode Enabled", myMousePB.interfaceRef);
  97.             
  98.             if (myMousePB.pCursorDeviceInfo == 0)
  99.             {
  100.                 myMousePB.pCursorDeviceInfo = &myMousePB.cursorDeviceInfo;
  101.                 CursorDeviceNewDevice(&myMousePB.pCursorDeviceInfo);
  102.                 
  103.                 CursorDeviceSetAcceleration(myMousePB.pCursorDeviceInfo, (Fixed)(1<<16));
  104.                 
  105.                 CursorDeviceSetButtons(myMousePB.pCursorDeviceInfo, 3);            // should actually be set by reading
  106.                                                                                 // the HID descriptor, but lacking
  107.                                                                                 // a parser, we'll just force it
  108.                                                                                 // this way.
  109.                 CursorDeviceButtonOp(myMousePB.pCursorDeviceInfo, 0, kButtonSingleClick, 0L);
  110.                 CursorDeviceButtonOp(myMousePB.pCursorDeviceInfo, 1, kButtonSingleClick, 0L);
  111.                 CursorDeviceButtonOp(myMousePB.pCursorDeviceInfo, 2, kButtonSingleClick, 0L);
  112.                 CursorDeviceUnitsPerInch(myMousePB.pCursorDeviceInfo, (Fixed)(myMousePB.unitsPerInch));
  113.             
  114.                 myMousePB.pSavedInterruptRoutine = myMousePB.pSHIMInterruptRoutine;
  115.                 myMousePB.pSHIMInterruptRoutine = USBMouseIn;
  116.             }
  117.             break;
  118.  
  119.         case kHIDDisableDemoMode:
  120.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Demo Mode Disabled", myMousePB.interfaceRef);
  121.             if (myMousePB.pCursorDeviceInfo != 0)
  122.             {
  123.                 CursorDeviceDisposeDevice(myMousePB.pCursorDeviceInfo);
  124.                 myMousePB.pCursorDeviceInfo = 0;
  125.             }
  126.             myMousePB.pSHIMInterruptRoutine = myMousePB.pSavedInterruptRoutine;
  127.             break;
  128.  
  129.         default:
  130.             return paramErr;
  131.     }
  132.     return noErr;
  133. }
  134.  
  135.  
  136.  
  137. OSStatus USBHIDGetDeviceInfo(UInt32 theInfoSelector, void * theInfo)
  138. {
  139. HIDInterruptProcPtr * pHIDIntProcPtr;
  140. UInt32 * pUnits;
  141. UInt32 * pInterruptRefcon;
  142.  
  143.     switch (theInfoSelector)
  144.     {
  145.         case kHIDGetDeviceUnitsPerInch:
  146.             pUnits = (UInt32*)theInfo;
  147.             *pUnits = (UInt32)(myMousePB.unitsPerInch);
  148.             break;
  149.             
  150.         case kHIDGetInterruptHandler:
  151.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Get interrupt pointer", (UInt32)(myMousePB.pSHIMInterruptRoutine));
  152.             pHIDIntProcPtr = (HIDInterruptProcPtr *)theInfo;     
  153.             *pHIDIntProcPtr = myMousePB.pSHIMInterruptRoutine;
  154.             break;
  155.  
  156.         case kHIDGetInterruptRefcon:
  157.             pInterruptRefcon = (UInt32 *)theInfo;
  158.             *pInterruptRefcon = myMousePB.interruptRefcon;
  159.             break;
  160.         
  161.         default:
  162.             return paramErr;
  163.     }
  164.     return noErr;
  165. }
  166.  
  167. OSStatus USBHIDEnterPolledMode(void)
  168. {
  169.     return unimpErr;
  170. }
  171.  
  172. OSStatus USBHIDExitPolledMode(void)
  173. {
  174.     return unimpErr;
  175. }
  176.  
  177. void NotifyRegisteredHIDUser(UInt32 devicetype, UInt8 hidReport[])
  178. {
  179. #pragma unused (devicetype)
  180.  
  181. USBHIDData        theMouseData;
  182. SInt8            myXDelta, myYDelta;
  183.  
  184.     theMouseData.mouse.buttons = (UInt16)hidReport[0];
  185.     
  186.     myXDelta = (SInt8)hidReport[1];
  187.     myYDelta = (SInt8)hidReport[2];  
  188.     
  189.     theMouseData.mouse.XDelta = (SInt16)myXDelta;
  190.     theMouseData.mouse.YDelta = (SInt16)myYDelta;
  191.     if (myMousePB.pSHIMInterruptRoutine)
  192.     {
  193.         (*myMousePB.pSHIMInterruptRoutine)(myMousePB.interruptRefcon, (void *)&theMouseData);
  194.     }
  195. }
  196.  
  197. USBHIDModuleDispatchTable TheHIDModuleDispatchTable =
  198. {
  199.     (UInt32)0,
  200.     (USBHIDInstallInterruptProcPtr)USBHIDInstallInterrupt,
  201.     (USBHIDPollDeviceProcPtr)USBHIDPollDevice,
  202.     (USBHIDControlDeviceProcPtr)USBHIDControlDevice,
  203.     (USBHIDGetDeviceInfoProcPtr)USBHIDGetDeviceInfo,
  204.     (USBHIDEnterPolledModeProcPtr)USBHIDEnterPolledMode,
  205.     (USBHIDExitPolledModeProcPtr)USBHIDExitPolledMode
  206. };
  207.  
  208. CursorDevicePtr gUSBMouse;
  209. CursorDevice    ourDevice;
  210.  
  211.